{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 第2章 机器学习概述\n",
    "\n",
    "**机器学习**（Machine Learning，ML）就是让计算机从数据中进行自动学习，得到某种知识（或规律）。作为一门学科，机器学习通常指一类问题以及解决这类问题的方法，即如何从观测数据（样本）中寻找规律，并利用学习到的规律（模型）对未知或无法观测的数据进行预测。\n",
    "\n",
    "在学习本章内容前，建议您先阅读《神经网络与深度学习》第 2 章：机器学习概述的相关内容，关键知识点如**图2.1**所示，以便更好的理解和掌握相应的理论知识，及其在实践中的应用方法。\n",
    "\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/4a0ba02cd1854203b7008f8482eaa0f533a55e49900c4fb8b44063ef0a4d7572\" width=400></center>\n",
    "<br><center>图2.1 《神经网络与深度学习》关键知识点回顾</center></br>\n",
    "\n",
    "本章内容基于《神经网络与深度学习》第 2 章：机器学习概述 相关内容进行设计，主要包含两部分：\n",
    "\n",
    "* **模型解读**：介绍机器学习实践五要素（数据、模型、学习准则、优化算法、评估指标）的原理剖析和相应的代码实现。通过理论和代码的结合，加深对机器学习的理解；\n",
    "* **案例实践**：基于机器学习线性回归方法，通过数据处理、模型构建、训练配置、组装训练框架Runner、模型训练和模型预测等过程完成波士顿房价预测任务。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.1 机器学习实践五要素\n",
    "\n",
    "要通过机器学习来解决一个特定的任务时，我们需要准备5个方面的要素：\n",
    "1. 数据集：收集任务相关的数据集用来进行模型训练和测试，可分为训练集、验证集和测试集；\n",
    "1. 模型：实现输入到输出的映射，通常为可学习的函数；\n",
    "1. 学习准则：模型优化的目标，通常为损失函数和正则化项的加权组合；\n",
    "1. 优化算法：根据学习准则优化机器学习模型的参数；\n",
    "1. 评价指标：用来评价学习到的机器学习模型的性能．\n",
    "\n",
    "**图2.2**给出实现一个完整的机器学习系统的主要环节和要素。从流程角度看，实现机器学习系统可以分为两个阶段：训练阶段和评价阶段。训练阶段需要用到训练集、验证集、待学习的模型、损失函数、优化算法，输出学习到的模型；评价阶段也称为测试阶段，需要用到测试集、学习到的模型、评价指标体系，得到模型的性能评价。\n",
    "\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/c6659949ce3b4c4683a3f82d7b9683b0d341ee57b87f4fb084be58e31dbe7f92\" width=500></center>\n",
    "\n",
    "<br><center>图2.2 机器学习系统示例</center></br>\n",
    "\n",
    "<br>\n",
    "\n",
    "在本节中，我们分别对这五个要素进行简单的介绍。\n",
    "\n",
    "****\n",
    "《神经网络与深度学习》第 2.2 节详细介绍了机器学习的三个基本要素：“模型”、“学习准则”和“优化算法”．在机器学习实践中，“数据”和“评价指标”也非常重要．因此，本书将机器学习在实践中的主要元素归结为五要素．\n",
    "****\n",
    "\n",
    "### 2.1.1 数据\n",
    "\n",
    "在实践中，数据的质量会很大程度上影响模型最终的性能，通常数据预处理是完成机器学习实践的第一步，噪音越少、规模越大、覆盖范围越广的数据集往往能够训练出性能更好的模型。数据预处理可分为两个环节：先对收集到的数据进行基本的预处理，如基本的统计、特征归一化和异常值处理等；再将数据划分为训练集、验证集（开发集）和测试集。\n",
    "* **训练集**：用于模型训练时调整模型的参数，在这份数据集上的误差被称为训练误差；\n",
    "* **验证集（开发集）**：对于复杂的模型，常常有一些超参数需要调节，因此需要尝试多种超参数的组合来分别训练多个模型，然后对比它们在验证集上的表现，选择一组相对最好的超参数，最后才使用这组参数下训练的模型在测试集上评估测试误差。\n",
    "* **测试集**：模型在这份数据集上的误差被称为测试误差。训练模型的目的是为了通过从训练数据中找到规律来预测未知数据，因此测试误差是更能反映出模型表现的指标。\n",
    "\n",
    "数据划分时要考虑到两个因素：更多的训练数据会降低参数估计的方差，从而得到更可信的模型；而更多的测试数据会降低测试误差的方差，从而得到更可信的测试误差。如果给定的数据集没有做任何划分，我们一般可以大致按照7:3或者8:2的比例划分训练集和测试集，再根据7:3或者8:2的比例从训练集中再次划分出训练集和验证集。\n",
    "\n",
    "----\n",
    "需要强调的是，测试集只能用来评测模型最终的性能，在整个模型训练过程中不能有测试集的参与。\n",
    "\n",
    "\n",
    "### 2.1.2 模型\n",
    "\n",
    "有了数据后，我们可以用数据来训练模型。我们希望能让计算机从一个函数集合 $\\mathcal{F} = \\{f_1(\\boldsymbol{x}), f_2(\\boldsymbol{x}), \\cdots \\}$中\n",
    "自动寻找一个“最优”的函数$f^∗(\\boldsymbol{x})$ 来近似每个样本的特征向量 $\\boldsymbol{x}$ 和标签 $y$ 之间\n",
    "的真实映射关系，实际上这个函数集合也被称为**假设空间**，在实际问题中，假设空间$\\mathcal{F}$通常为一个参数化的函数族\n",
    "$$\n",
    "\\mathcal{F}=\\left\\{f(\\boldsymbol{x} ; \\theta) \\mid \\theta \\in \\mathbb{R}^{D}\\right\\}, (2.1)\n",
    "$$\n",
    "其中$f(\\boldsymbol{x} ; \\theta)$是参数为$\\theta$的函数，也称为模型，𝐷 为参数的数量。\n",
    "\n",
    "\n",
    "常见的假设空间可以分为线性和非线性两种，对应的模型 $f$ 也分别称为线性模型和非线性模型。**线性模型**的假设空间为一个参数化的线性函数族，即：\n",
    "$$\n",
    "f(\\boldsymbol{x} ; \\theta)=\\boldsymbol{w}^{\\top} \\boldsymbol{x}+b, (2.2)\n",
    "$$\n",
    "其中参数$\\theta$ 包含了权重向量$\\boldsymbol{w}$和偏置$b$。\n",
    "\n",
    "线性模型可以由**非线性基函数**$\\phi(\\boldsymbol{x})$变为**非线性模型**，从而增强模型能力:\n",
    "\n",
    "$$\n",
    "f(\\boldsymbol{x} ; \\theta)=\\boldsymbol{w}^{\\top} \\phi(\\boldsymbol{x})+b, (2.3)\n",
    "$$\n",
    "其中$\\phi(\\boldsymbol{x})=\\left[\\phi_{1}(\\boldsymbol{x}), \\phi_{2}(\\boldsymbol{x}), \\cdots, \\phi_{K}(\\boldsymbol{x})\\right]^{\\top}$为𝐾 个非线性基函数组成的向量，参数 $\\theta$ 包含了权重向量$\\boldsymbol{w}$和偏置$b$。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.1.3 学习准则\n",
    "\n",
    "为了衡量一个模型的好坏，我们需要定义一个损失函数$\\mathcal{L}(\\boldsymbol{y},f(\\boldsymbol{x};\\theta))$。损失函数是一个非负实数函数，用来量化模型预测标签和真实标签之间的差异。常见的损失函数有 0-1 损失、平方损失函数、交叉熵损失函数等。\n",
    "\n",
    "机器学习的目标就是找到最优的模型$𝑓(𝒙;\\theta^∗)$在真实数据分布上损失函数的期望最小。然而在实际中，我们无法获得真实数据分布，通常会用在训练集上的平均损失替代。\n",
    "\n",
    "一个模型在训练集$\\mathcal{D}=\\{(\\boldsymbol{x}^{(n)},y^{(n)})\\}_{n=1}^N$上的平均损失称为**经验风险**{Empirical Risk}，即:\n",
    "\n",
    "$$\n",
    "\\mathcal{R}^{emp}_\\mathcal{D}(\\theta)=\\frac{1}{N}\\sum_{n=1}^{N}\\mathcal{L}(y^{(n)},f({x}^{(n)};\\theta))。 (2.4)\n",
    "$$\n",
    "\n",
    "$\\mathcal{L}(\\boldsymbol{y},f(\\boldsymbol{x};\\theta))$为损失函数。损失函数是一个非负实数函数，用来量化模型预测和真实标签之间的差异。常见的损失函数有0-1损失、平方损失函数、交叉熵损失函数等。\n",
    "\n",
    "在通常情况下，我们可以通过使得**经验风险最小化**来获得具有预测能力的模型。然而，当模型比较复杂或训练数据量比较少时，经验风险最小化获得的模型在测试集上的效果比较差。而模型在测试集上的性能才是我们真正关心的指标．当一个模型在训练集错误率很低，而在测试集上错误率较高时，通常意味着发生了**过拟合**（Overfitting）现象。为了缓解模型的过拟合问题，我们通常会在经验损失上加上一定的正则化项来限制模型能力。\n",
    "\n",
    "过拟合通常是由于模型复杂度比较高引起的。在实践中，最常用的正则化方式有对模型的参数进行约束，比如$\\ell_1$或者$\\ell_2$范数约束。这样，我们就得到了结构风险（Structure Risk）。\n",
    "$$\n",
    "\\mathcal{R}^{struct}_{\\mathcal{D}}(\\theta)=\\mathcal{R}^{emp}_{\\mathcal{D}}(\\theta)+\\lambda \\ell_p(\\theta), (2.5)\n",
    "$$\n",
    "\n",
    "其中$\\lambda$为正则化系数，$p=1$或$2$表示$\\ell_1$或者$\\ell_2$范数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.1.4 优化算法\n",
    "在有了优化目标之后，机器学习问题就转化为优化问题，我们可以利用已知的优化算法来学习最优的参数。当优化函数为凸函数时，我们可以令参数的偏导数等于0来计算最优参数的解析解。当优化函数为非凸函数时，我们可以用一阶的优化算法来进行优化。\n",
    "\n",
    "目前机器学习中最常用的优化算法是**梯度下降法**(Gradient Descent Method)。\n",
    "当使用梯度下降法进行参数优化时，还可以利用验证集来**早停法**(Early-Stop)来中止模型的优化过程，避免模型在训练集上过拟合。早停法也是一种常用并且十分有效的正则化方法。\n",
    "\n",
    "### 2.2.5 评估指标\n",
    "\n",
    "**评估指标**(Metric)用于评价模型效果，即给定一个测试集，用模型对测试集中的每个样本进行预测，并根据预测结果计算评价分数。回归任务的评估指标一般有预测值与真实值的均方差，分类任务的评估指标一般有准确率、召回率、F1值等。\n",
    "\n",
    "****\n",
    "对于一个机器学习任务，一般会先确定任务类型，再确定任务的评价指标，再根据评价指标来建立模型，选择学习准则。由于评价指标不可微等问题有时候学习准则并不能完全和评价指标一致，我们往往会选择一定的损失函数使得两者尽可能一致。\n",
    "****"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.2 实现一个简单的线性回归模型\n",
    "**回归任务**是一类典型的监督机器学习任务，对自变量和因变量之间关系进行建模分析，其预测值通常为一个连续值，比如房屋价格预测、电源票房预测等。**线性回归**(Linear Regression)是指一类利用线性函数来对自变量和因变量之间关系进行建模的回归任务，是机器学习和统计学中最基础和最广泛应用的模型。\n",
    "\n",
    "在本节中，我们动手实现一个简单的线性回归模型，并使用最小二乘法来求解参数，以对机器学习任务有更直观的认识。\n",
    "\n",
    "### 2.2.1 数据集构建\n",
    "\n",
    "首先，我们构造一个小的回归数据集。假设输入特征和输出标签的维度都为 1，需要被拟合的函数定义为：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 真实函数的参数缺省值为 w=1.2，b=0.5\n",
    "def linear_func(x,w=1.2,b=0.5):\n",
    "    y = w*x + b\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "然后，使用`paddle.rand()`函数来进行随机采样输入特征$x$，并代入上面函数得到输出标签$𝑦$。为了模拟真实环境中样本通常包含噪声的问题，我们采样过程中加入高斯噪声和异常点。\n",
    "\n",
    "生成样本数据的函数`create_toy_data`实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import paddle\n",
    "\n",
    "def create_toy_data(func, interval, sample_num, noise = 0.0, add_outlier = False, outlier_ratio = 0.001):\n",
    "    \"\"\"\n",
    "    根据给定的函数，生成样本\n",
    "    输入：\n",
    "       - func：函数\n",
    "       - interval： x的取值范围\n",
    "       - sample_num： 样本数目\n",
    "       - noise： 噪声均方差\n",
    "       - add_outlier：是否生成异常值\n",
    "       - outlier_ratio：异常值占比\n",
    "    输出：\n",
    "       - X: 特征数据，shape=[n_samples,1]\n",
    "       - y: 标签数据，shape=[n_samples,1]\n",
    "    \"\"\"\n",
    "\n",
    "    # 均匀采样\n",
    "    # 使用paddle.rand在生成sample_num个随机数\n",
    "    X = paddle.rand(shape = [sample_num]) * (interval[1]-interval[0]) + interval[0]\n",
    "    y = func(X)\n",
    "\n",
    "    # 生成高斯分布的标签噪声\n",
    "    # 使用paddle.normal生成0均值，noise标准差的数据\n",
    "    epsilon = paddle.normal(0,noise,paddle.to_tensor(y.shape[0]))\n",
    "    y = y + epsilon\n",
    "    if add_outlier:     # 生成额外的异常点\n",
    "        outlier_num = int(len(y)*outlier_ratio)\n",
    "        if outlier_num != 0:\n",
    "            # 使用paddle.randint生成服从均匀分布的、范围在[0, len(y))的随机Tensor\n",
    "            outlier_idx = paddle.randint(len(y),shape = [outlier_num])\n",
    "            y[outlier_idx] = y[outlier_idx] * 5\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "利用上面的生成样本函数，生成 150 个带噪音的样本，其中 100 个训练样本，50 个测试样本，并打印出训练数据的可视化分布。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/__init__.py:107: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import MutableMapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/rcsetup.py:20: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Iterable, Mapping\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/colors.py:53: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Sized\n",
      "W0723 07:21:25.679682   208 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 8.0, Driver API Version: 11.2, Runtime API Version: 11.2\n",
      "W0723 07:21:25.682767   208 device_context.cc:465] device: 0, cuDNN Version: 8.2.\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2349: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  if isinstance(obj, collections.Iterator):\n",
      "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:2366: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  return list(data) if isinstance(data, collections.MappingView) else data\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt # matplotlib 是 Python 的绘图库\n",
    "\n",
    "func = linear_func\n",
    "interval = (-10,10)\n",
    "train_num = 100 # 训练样本数目\n",
    "test_num = 50 # 测试样本数目\n",
    "noise = 2\n",
    "X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise, add_outlier = False)\n",
    "X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise, add_outlier = False)\n",
    "\n",
    "X_train_large, y_train_large = create_toy_data(func=func, interval=interval, sample_num=5000, noise = noise, add_outlier = False)\n",
    "\n",
    "# paddle.linspace返回一个Tensor，Tensor的值为在区间start和stop上均匀间隔的num个值，输出Tensor的长度为num\n",
    "X_underlying = paddle.linspace(interval[0],interval[1],train_num) \n",
    "y_underlying = linear_func(X_underlying)\n",
    "\n",
    "# 绘制数据\n",
    "plt.scatter(X_train, y_train, marker='*', facecolor=\"none\", edgecolor='#e4007f', s=50, label=\"train data\")\n",
    "plt.scatter(X_test, y_test, facecolor=\"none\", edgecolor='#f19ec2', s=50, label=\"test data\")\n",
    "plt.plot(X_underlying, y_underlying, c='#000000', label=r\"underlying distribution\")\n",
    "plt.legend(fontsize='x-large') # 给图像加图例\n",
    "plt.savefig('ml-vis.pdf') # 保存图像到PDF文件中\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2.2 模型构建\n",
    "\n",
    "在线性回归中，自变量为样本的特征向量$\\boldsymbol{x}\\in \\mathbb{R}^D$(每一维对应一个自变量)，因变量是连续值的标签$y\\in R$。\n",
    "\n",
    "线性模型定义为：\n",
    "$$\n",
    "f(\\boldsymbol{x};\\boldsymbol{w},b)=\\boldsymbol{w}^T\\boldsymbol{x}+b。 (2.6)\n",
    "$$\n",
    "\n",
    "其中权重向量$\\boldsymbol{w}\\in \\mathbb{R}^D$和偏置$b\\in \\mathbb{R}$都是可学习的参数。\n",
    "\n",
    "****\n",
    "注意：《神经网络与深度学习》中为了表示的简洁性，使用**增广权重向量**来定义模型。而在本书中，为了和代码实现保持一致，我们使用非增广向量的形式来定义模型。\n",
    "****\n",
    "\n",
    "在实践中，为了提高预测样本的效率，我们通常会将$N$样本归为一组进行成批地预测，这样可以更好地利用GPU设备的并行计算能力。\n",
    "\n",
    "$$\n",
    "\\boldsymbol{y} =\\boldsymbol{X} \\boldsymbol{w} + b, (2.7)\n",
    "$$\n",
    "\n",
    "其中$\\boldsymbol{X}\\in \\mathbb{R}^{N\\times D}$为$N$个样本的特征矩阵，$\\boldsymbol{y}\\in \\mathbb{R}^N$为$N$个预测值组成的列向量。\n",
    "\n",
    "****\n",
    "注意：在实践中，样本的矩阵$\\boldsymbol{X}$是由$N$个$\\boldsymbol{x}$的**行向量**组成。而原教材中$\\boldsymbol{x}$为列向量，其特征矩阵与本书中的特征矩阵刚好为转置关系。\n",
    "****"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 2.2.2.1 线性算子\n",
    "实现公式(2.7)中的线性函数非常简单，我们直接利用如下张量运算来实现。\n",
    "```\n",
    "# X: tensor, shape=[N,D]\n",
    "# y_pred: tensor, shape=[N]\n",
    "# w: shape=[D,1]\n",
    "# b: shape=[1]\n",
    "y_pred = paddle.matmul(X,w)+b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "使用飞桨构建一个线性回归模型，代码如下：\n",
    "**** \n",
    "**说明**\n",
    "\n",
    "在飞桨框架中，可以直接调用模型的`forward()`方法进行前向执行，也可以调用`__call__()`，从而执行在 `forward()` 当中定义的前向计算逻辑。\n",
    "\n",
    "在飞桨框架中，模型一般继承[nn.Layer](https://www.paddlepaddle.org.cn/documentation/docs/en/api/paddle/nn/Layer_en.html)，在成员函数`forward()`中执行模型的前向运算。由于本案例较简单，所以没有继承`nn.Layer`，但是保留了在`forward()`函数中执行模型的前向运算的过程。\n",
    "****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_pred: Tensor(shape=[2, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[-7.14921522],\n",
      "        [ 3.71592045]])\n"
     ]
    }
   ],
   "source": [
    "import paddle\r\n",
    "from nndl.op import Op\r\n",
    "\r\n",
    "paddle.seed(10) #设置随机种子\r\n",
    "\r\n",
    "# 线性算子\r\n",
    "class Linear(Op):\r\n",
    "    def __init__(self, input_size):\r\n",
    "        \"\"\"\r\n",
    "        输入：\r\n",
    "           - input_size:模型要处理的数据特征向量长度\r\n",
    "        \"\"\"\r\n",
    "\r\n",
    "        self.input_size = input_size\r\n",
    "\r\n",
    "        # 模型参数\r\n",
    "        self.params = {}\r\n",
    "        self.params['w'] = paddle.randn(shape=[self.input_size,1],dtype='float32') \r\n",
    "        self.params['b'] = paddle.zeros(shape=[1],dtype='float32')\r\n",
    "\r\n",
    "    def __call__(self, X):\r\n",
    "        return self.forward(X)\r\n",
    "\r\n",
    "    # 前向函数\r\n",
    "    def forward(self, X):\r\n",
    "        \"\"\"\r\n",
    "        输入：\r\n",
    "           - X: tensor, shape=[N,D]\r\n",
    "           注意这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致\r\n",
    "        输出：\r\n",
    "           - y_pred： tensor, shape=[N]\r\n",
    "        \"\"\"\r\n",
    "\r\n",
    "        N,D = X.shape\r\n",
    "\r\n",
    "        if self.input_size==0:\r\n",
    "            return paddle.full(shape=[N,1], fill_value=self.params['b'])\r\n",
    "        \r\n",
    "        assert D==self.input_size # 输入数据维度合法性验证\r\n",
    "\r\n",
    "        # 使用paddle.matmul计算两个tensor的乘积\r\n",
    "        y_pred = paddle.matmul(X,self.params['w'])+self.params['b']\r\n",
    "        \r\n",
    "        return y_pred\r\n",
    "\r\n",
    "# 注意这里我们为了和后面章节统一，这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致\r\n",
    "input_size = 3\r\n",
    "N = 2\r\n",
    "X = paddle.randn(shape=[N, input_size],dtype='float32') # 生成2个维度为3的数据\r\n",
    "model = Linear(input_size)\r\n",
    "y_pred = model(X)\r\n",
    "print(\"y_pred:\",y_pred) #输出结果的个数也是2个"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2.3 损失函数\n",
    "回归任务是对**连续值**的预测，希望模型能根据数据的特征输出一个连续值作为预测值。因此回归任务中常用的评估指标是**均方误差**。\n",
    "\n",
    "令$\\boldsymbol{y}\\in \\mathbb{R}^N$，$\\hat{\\boldsymbol{y}}\\in \\mathbb{R}^N$分别为$N$个样本的真实标签和预测标签，均方误差的定义为：\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\boldsymbol{y},\\hat{\\boldsymbol{y}})=\\frac{1}{2N}\\|\\boldsymbol{y}-\\hat{\\boldsymbol{y}}\\|^2=\\frac{1}{2N}\\|\\boldsymbol{X}\\boldsymbol{w}+\\boldsymbol{b}-\\boldsymbol{y}\\|^2, (2.8)\n",
    "$$\n",
    "其中$\\boldsymbol{b}$为$N$维向量，所有元素取值都为$b$。\n",
    "\n",
    "均方误差的代码实现如下:\n",
    "> 注意：代码实现中没有除2。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error: 4.005000114440918\n"
     ]
    }
   ],
   "source": [
    "import paddle\n",
    "\n",
    "def mean_squared_error(y_true, y_pred):\n",
    "    \"\"\"\n",
    "    输入：\n",
    "       - y_true: tensor，样本真实标签\n",
    "       - y_pred: tensor, 样本预测标签\n",
    "    输出：\n",
    "       - error: float，误差值\n",
    "    \"\"\"\n",
    "\n",
    "    assert y_true.shape[0] == y_pred.shape[0]\n",
    "    \n",
    "    # paddle.square计算输入的平方值\n",
    "    # paddle.mean沿 axis 计算 x 的平均值，默认axis是None，则对输入的全部元素计算平均值。\n",
    "    error = paddle.mean(paddle.square(y_true - y_pred))\n",
    "\n",
    "    return error\n",
    "\n",
    "\n",
    "# 构造一个简单的样例进行测试:[N,1], N=2\n",
    "y_true= paddle.to_tensor([[-0.2],[4.9]],dtype='float32')\n",
    "y_pred = paddle.to_tensor([[1.3],[2.5]],dtype='float32')\n",
    "\n",
    "error = mean_squared_error(y_true=y_true, y_pred=y_pred).item()\n",
    "print(\"error:\",error)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2.4 模型优化\n",
    "\n",
    "采用**经验风险最小化**，线性回归可以通过最小二乘法求出参数$\\boldsymbol{w}$和$b$的解析解。计算公式(2.8)中均方误差对参数$b$的偏导数，得到\n",
    "$$\n",
    "\\frac{\\partial \\mathcal{L}(\\boldsymbol{y},\\hat{\\boldsymbol{y}})}{\\partial b} = \\mathbf{1}^T (\\boldsymbol{X}\\boldsymbol{w}+\\boldsymbol{b}-\\boldsymbol{y}), (2.9)\n",
    "$$\n",
    "\n",
    "其中$\\mathbf{1}$为$N$维的全1向量。**这里为了简单起见省略了均方误差的系数$\\frac{1}{N}$，并不影响最后的结果**。\n",
    "\n",
    "令上式等于0，得到\n",
    "$$\n",
    "b^* =\\bar{y}-\\bar{\\boldsymbol{x}}^T \\boldsymbol{w},(2.10)\n",
    "$$\n",
    "\n",
    "其中$\\bar{y} = \\frac{1}{N}\\mathbf{1}^T\\boldsymbol{y}$为所有标签的平均值，$\\bar{\\boldsymbol{x}} = \\frac{1}{N}(\\mathbf{1}^T \\boldsymbol{X})^T$ 为所有特征向量的平均值。将$b^*$代入公式(2.8)中均方误差对参数$\\boldsymbol{w}$的偏导数，得到\n",
    "$$\n",
    "\\frac{\\partial \\mathcal{L}(\\boldsymbol{y},\\hat{\\boldsymbol{y}})}{\\partial \\boldsymbol{w}} = (\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)^T \\Big((\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)\\boldsymbol{w}-(\\boldsymbol{y}-\\bar{y})\\Big).(2.11)\n",
    "$$\n",
    "令上式等于0，得到最优的参数为\n",
    "$$\n",
    "\\boldsymbol{w}^*=\\Big((\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)^T(\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)\\Big)^{\\mathrm{-}1}(\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)^T (\\boldsymbol{y}-\\bar{y}),(2.12)\n",
    "$$\n",
    "\n",
    "$$\n",
    "b^* =  \\bar{y}-\\bar{\\boldsymbol{x}}^T \\boldsymbol{w}^*.(2.13)\n",
    "$$\n",
    "\n",
    "若对参数$\\boldsymbol{w}$加上$\\ell_2$正则化，则最优的$\\boldsymbol{w}^*$变为\n",
    "$$\n",
    "\\boldsymbol{w}^*=\\Big((\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)^T(\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)+\\lambda \\boldsymbol{I}\\Big)^{\\mathrm{-}1}(\\boldsymbol{X}-\\bar{\\boldsymbol{x}}^T)^T (\\boldsymbol{y}-\\bar{y}),(2.14)\n",
    "$$\n",
    "\n",
    "其中$\\lambda>0$为预先设置的正则化系数，$\\boldsymbol{I}\\in \\mathbb{R}^{D\\times D}$为单位矩阵。\n",
    "\n",
    "****\n",
    "尝试验证公式(2.14)。\n",
    "****"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "参数学习的过程通过优化器完成。由于我们可以基于最小二乘方法可以直接得到线性回归的解析解，此处的训练是求解析解的过程，代码实现如下：\n",
    "****\n",
    "注意：本案例基于飞桨2.2.2版本，飞桨2.1.2版本无法直接对paddle.Tensor求转置。\n",
    "****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def optimizer_lsm(model, X, y, reg_lambda=0):\n",
    "  \"\"\"\n",
    "    输入：\n",
    "       - model: 模型\n",
    "       - X: tensor, 特征数据，shape=[N,D]\n",
    "       - y: tensor,标签数据，shape=[N]\n",
    "       - reg_lambda: float, 正则化系数，默认为0\n",
    "    输出：\n",
    "       - model: 优化好的模型\n",
    "    \"\"\"\n",
    "\n",
    "  N, D = X.shape\n",
    "\n",
    "  # 对输入特征数据所有特征向量求平均\n",
    "  x_bar_tran = paddle.mean(X,axis=0).T \n",
    "  \n",
    "  # 求标签的均值,shape=[1]\n",
    "  y_bar = paddle.mean(y)\n",
    "  \n",
    "  # paddle.subtract通过广播的方式实现矩阵减向量\n",
    "  x_sub = paddle.subtract(X,x_bar_tran)\n",
    "\n",
    "  # 使用paddle.all判断输入tensor是否全0\n",
    "  if paddle.all(x_sub==0):\n",
    "    model.params['b'] = y_bar\n",
    "    model.params['w'] = paddle.zeros(shape=[D])\n",
    "    return model\n",
    "  \n",
    "  # paddle.inverse求方阵的逆\n",
    "  tmp = paddle.inverse(paddle.matmul(x_sub.T,x_sub)+\n",
    "          reg_lambda*paddle.eye(num_rows = (D)))\n",
    "\n",
    "  w = paddle.matmul(paddle.matmul(tmp,x_sub.T),(y-y_bar))\n",
    "  \n",
    "  b = y_bar-paddle.matmul(x_bar_tran,w)\n",
    "  \n",
    "  model.params['b'] = b\n",
    "  model.params['w'] = paddle.squeeze(w,axis=-1)\n",
    "\n",
    "  return model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2.5 模型训练\n",
    "\n",
    "在准备了数据、模型、损失函数和参数学习的实现之后，我们开始模型的训练。在回归任务中，模型的评价指标和损失函数一致，都为均方误差。\n",
    "\n",
    "通过上文实现的线性回归类来拟合训练数据，并输出模型在训练集上的损失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w_pred: 1.1939243078231812 b_pred:  0.3950345516204834\n",
      "train error:  3.9752702713012695\n"
     ]
    }
   ],
   "source": [
    "input_size = 1\n",
    "model = Linear(input_size)\n",
    "model = optimizer_lsm(model,X_train.reshape([-1,1]),y_train.reshape([-1,1]))\n",
    "print(\"w_pred:\",model.params['w'].item(), \"b_pred: \", model.params['b'].item())\n",
    "\n",
    "y_train_pred = model(X_train.reshape([-1,1])).squeeze()\n",
    "train_error = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()\n",
    "print(\"train error: \",train_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w_pred large: 1.198974370956421 b_pred large:  0.4857105612754822\n",
      "train error large:  3.9665119647979736\n"
     ]
    }
   ],
   "source": [
    "model_large = Linear(input_size)\n",
    "model_large = optimizer_lsm(model_large,X_train_large.reshape([-1,1]),y_train_large.reshape([-1,1]))\n",
    "print(\"w_pred large:\",model_large.params['w'].item(), \"b_pred large: \", model_large.params['b'].item())\n",
    "\n",
    "y_train_pred_large = model_large(X_train_large.reshape([-1,1])).squeeze()\n",
    "train_error_large = mean_squared_error(y_true=y_train_large, y_pred=y_train_pred_large).item()\n",
    "print(\"train error large: \",train_error_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "从输出结果看，预测结果与真实值$\\boldsymbol{w}=1.2$，$b=0.5$有一定的差距。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.2.6 模型评估\n",
    "下面用训练好的模型预测一下测试集的标签，并计算在测试集上的损失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test error:  3.491741180419922\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = model(X_test.reshape([-1,1])).squeeze()\r\n",
    "test_error = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()\r\n",
    "print(\"test error: \",test_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test error large:  3.4849042892456055\n"
     ]
    }
   ],
   "source": [
    "y_test_pred_large = model_large(X_test.reshape([-1,1])).squeeze()\n",
    "test_error_large = mean_squared_error(y_true=y_test, y_pred=y_test_pred_large).item()\n",
    "print(\"test error large: \",test_error_large)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "****\n",
    "动手练习:\n",
    "\n",
    "为了加深对机器学习模型的理解，请自己动手完成以下实验：\n",
    "\n",
    "（1） 调整训练数据的样本数量，由 100 调整到 5000，观察对模型性能的影响。\n",
    "\n",
    "（2） 调整正则化系数，观察对模型性能的影响。\n",
    "****"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2.3 多项式回归\n",
    "\n",
    "多项式回归是回归任务的一种形式，其中自变量和因变量之间的关系是$M$次多项式的一种线性回归形式，即：\n",
    "$$\n",
    "f(\\boldsymbol{x};\\boldsymbol{w})=w_1x+w_2x^2+...+w_Mx^M+b=\\boldsymbol{w}^T\\phi(x)+b, （2.10）\n",
    "$$\n",
    "其中$M$为多项式的阶数，$\\boldsymbol{w}=[w_1,...,w_M]^T$为多项式的系数，$\\phi(x)=[x,x^2,\\cdots,x^M]^T$为多项式基函数，将原始特征$x$映射为$M$维的向量。当$M=0$时，$f(\\boldsymbol{x};\\boldsymbol{w})=b$。\n",
    "\n",
    "公式（2.10）展示的是特征维度为1的多项式表达，当特征维度大于1时，存在不同特征之间交互的情况，这是线性回归无法实现。公式（2.11）展示的是当特征维度为2，多项式阶数为2时的多项式回归：\n",
    "\n",
    "$$\n",
    "f(\\boldsymbol{x};\\boldsymbol{w})=w_1x_1+w_2x_2+w_3x_1^2+w_4x_1x_2+w_5x_2^2+b, （2.11）\n",
    "$$\n",
    "\n",
    "****\n",
    "当自变量和因变量之间并不是线性关系时，我们可以定义非线性基函数对特征进行变换，从而可以使得线性回归算法实现非线性的曲线拟合。\n",
    "****\n",
    "\n",
    "接下来我们基于特征维度为1的自变量介绍多项式回归实验。\n",
    "\n",
    "### 2.3.1 数据集构建\n",
    "\n",
    "假设我们要拟合的非线性函数为一个缩放后的$sin$函数。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "# sin函数: sin(2 * pi * x)\n",
    "def sin(x):\n",
    "    y = paddle.sin(2 * math.pi * x)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "这里仍然使用前面定义的`create_toy_data`函数来构建训练和测试数据，其中训练数样本 15 个，测试样本 10 个，高斯噪声标准差为 0.1，自变量范围为 (0,1)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 生成数据\n",
    "func = sin\n",
    "interval = (0,1)\n",
    "train_num = 15\n",
    "test_num = 10\n",
    "noise = 0.5 #0.1 \n",
    "X_train, y_train = create_toy_data(func=func, interval=interval, sample_num=train_num, noise = noise)\n",
    "X_test, y_test = create_toy_data(func=func, interval=interval, sample_num=test_num, noise = noise)\n",
    "\n",
    "X_underlying = paddle.linspace(interval[0],interval[1],num=100)\n",
    "y_underlying = sin(X_underlying)\n",
    "\n",
    "# 绘制图像\n",
    "plt.rcParams['figure.figsize'] = (8.0, 6.0)\n",
    "plt.scatter(X_train, y_train, facecolor=\"none\", edgecolor='#e4007f', s=50, label=\"train data\")\n",
    "#plt.scatter(X_test, y_test, facecolor=\"none\", edgecolor=\"r\", s=50, label=\"test data\")\n",
    "plt.plot(X_underlying, y_underlying, c='#000000', label=r\"$\\sin(2\\pi x)$\")\n",
    "plt.legend(fontsize='x-large')\n",
    "plt.savefig('ml-vis2.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "在输出结果中，绿色的曲线是周期为 1 的 $sin$ 函数曲线，蓝色的圆圈为生成的训练样本数据，红色的圆圈为生成的测试样本数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.3.2 模型构建\n",
    "通过多项式的定义可以看出，多项式回归和线性回归一样，同样学习参数$\\boldsymbol{w}$，只不过需要对输入特征$\\phi(x)$根据多项式阶数进行变换。因此，我们可以套用求解线性回归参数的方法来求解多项式回归参数。\n",
    "\n",
    "首先，我们实现**多项式基函数**`polynomial_basis_function`对原始特征$x$进行转换。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "转换前： Tensor(shape=[3, 1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[2.],\n",
      "        [3.],\n",
      "        [4.]])\n",
      "阶数为 3 转换后： Tensor(shape=[3, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [[2. , 4. , 8. ],\n",
      "        [3. , 9. , 27.],\n",
      "        [4. , 16., 64.]])\n"
     ]
    }
   ],
   "source": [
    "# 多项式转换\n",
    "def polynomial_basis_function(x, degree = 2):\n",
    "    \"\"\"\n",
    "    输入：\n",
    "       - x: tensor, 输入的数据，shape=[N,1]\n",
    "       - degree: int, 多项式的阶数\n",
    "       example Input: [[2], [3], [4]], degree=2\n",
    "       example Output: [[2^1, 2^2], [3^1, 3^2], [4^1, 4^2]]\n",
    "       注意：本案例中,在degree>=1时不生成全为1的一列数据；degree为0时生成形状与输入相同，全1的Tensor\n",
    "    输出：\n",
    "       - x_result： tensor\n",
    "    \"\"\"\n",
    "    \n",
    "    if degree==0:\n",
    "        return paddle.ones(shape = x.shape,dtype='float32') \n",
    "\n",
    "    x_tmp = x\n",
    "    x_result = x_tmp\n",
    "\n",
    "    for i in range(2, degree+1):\n",
    "        x_tmp = paddle.multiply(x_tmp,x) # 逐元素相乘\n",
    "        x_result = paddle.concat((x_result,x_tmp),axis=-1)\n",
    "\n",
    "    return x_result\n",
    "\n",
    "# 简单测试\n",
    "data = [[2], [3], [4]]\n",
    "X = paddle.to_tensor(data = data,dtype='float32')\n",
    "degree = 3\n",
    "transformed_X = polynomial_basis_function(X,degree=degree)\n",
    "print(\"转换前：\",X)\n",
    "print(\"阶数为\",degree,\"转换后：\",transformed_X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 2.3.3 模型训练\n",
    "\n",
    "对于多项式回归，我们可以同样使用前面线性回归中定义的`LinearRegression`算子、训练函数`train`、均方误差函数`mean_squared_error`。拟合训练数据的目标是最小化损失函数，同线性回归一样，也可以通过矩阵运算直接求出$\\boldsymbol{w}$的值。\n",
    "\n",
    "我们设定不同的多项式阶，$M$的取值分别为0、1、3、8，之前构造的训练集上进行训练，观察样本数据对$\\sin$曲线的拟合结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'w': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [0.]), 'b': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [-0.14583507])}\n",
      "{'w': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [-2.25336981]), 'b': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [1.21663368])}\n",
      "{'w': Tensor(shape=[3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [ 14.82165051, -44.99418259,  30.95959663]), 'b': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [0.07141575])}\n",
      "{'w': Tensor(shape=[8], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [-17.20666504   ,  4623.21240234 , -13860.22265625,  8130.75537109 ,\n",
      "         1582.25048828 ,  12662.45996094, -10739.14648438,  5223.85644531 ]), 'b': Tensor(shape=[1], dtype=float32, place=CUDAPlace(0), stop_gradient=True,\n",
      "       [-1264.33691406])}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = (12.0, 8.0)\n",
    "\n",
    "for i, degree in enumerate([0, 1, 3, 8]): # []中为多项式的阶数\n",
    "    model = Linear(degree)\n",
    "    X_train_transformed = polynomial_basis_function(X_train.reshape([-1,1]), degree)\n",
    "    X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1,1]), degree)\n",
    "    \n",
    "    model = optimizer_lsm(model,X_train_transformed,y_train.reshape([-1,1])) #拟合得到参数\n",
    "\n",
    "    y_underlying_pred = model(X_underlying_transformed).squeeze()\n",
    "\n",
    "    print(model.params)\n",
    "    \n",
    "    # 绘制图像\n",
    "    plt.subplot(2, 2, i + 1)\n",
    "    plt.scatter(X_train, y_train, facecolor=\"none\", edgecolor='#e4007f', s=50, label=\"train data\")\n",
    "    plt.plot(X_underlying, y_underlying, c='#000000', label=r\"$\\sin(2\\pi x)$\")\n",
    "    plt.plot(X_underlying, y_underlying_pred, c='#f19ec2', label=\"predicted function\")\n",
    "    plt.ylim(-2, 1.5)\n",
    "    plt.annotate(\"M={}\".format(degree), xy=(0.95, -1.4))\n",
    "\n",
    "#plt.legend(bbox_to_anchor=(1.05, 0.64), loc=2, borderaxespad=0.)\n",
    "plt.legend(loc='lower left', fontsize='x-large')\n",
    "plt.savefig('ml-vis3.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "观察可视化结果，红色的曲线表示不同阶多项式分布拟合数据的结果：\n",
    "* 当 $M=0$ 或 $M=1$ 时，拟合曲线较简单，模型欠拟合；\n",
    "* 当 $M=8$ 时，拟合曲线较复杂，模型过拟合；\n",
    "* 当 $M=3$ 时，模型拟合最为合理。\n",
    "\n",
    "### 2.3.4 模型评估\n",
    "\n",
    "下面通过均方误差来衡量训练误差、测试误差以及在没有噪音的加入下`sin`函数值与多项式回归值之间的误差，更加真实地反映拟合结果。多项式分布阶数从0到8进行遍历。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train errors: \n",
      " [0.9289817810058594, 0.6049587726593018, 0.5504663586616516, 0.121650829911232, 7.12571907043457, 93501.765625, 1761911.5, 356893.6875, 3611387.5]\n",
      "test errors: \n",
      " [0.9318518042564392, 0.5504247546195984, 0.5263897180557251, 0.2421424686908722, 7.501934051513672, 97011.03125, 1816501.125, 353947.4375, 3919046.75]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 训练误差和测试误差\n",
    "training_errors = []\n",
    "test_errors = []\n",
    "distribution_errors = []\n",
    "\n",
    "# 遍历多项式阶数\n",
    "for i in range(9):\n",
    "    model = Linear(i)\n",
    "\n",
    "    X_train_transformed = polynomial_basis_function(X_train.reshape([-1,1]), i) \n",
    "    X_test_transformed = polynomial_basis_function(X_test.reshape([-1,1]), i) \n",
    "    X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1,1]), i)\n",
    "    \n",
    "    optimizer_lsm(model,X_train_transformed,y_train.reshape([-1,1]))\n",
    "    \n",
    "    y_train_pred = model(X_train_transformed).squeeze()\n",
    "    y_test_pred = model(X_test_transformed).squeeze()\n",
    "    y_underlying_pred = model(X_underlying_transformed).squeeze()\n",
    "\n",
    "    train_mse = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()\n",
    "    training_errors.append(train_mse)\n",
    "\n",
    "    test_mse = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()\n",
    "    test_errors.append(test_mse)\n",
    "\n",
    "    #distribution_mse = mean_squared_error(y_true=y_underlying, y_pred=y_underlying_pred).item()\n",
    "    #distribution_errors.append(distribution_mse)\n",
    "\n",
    "print (\"train errors: \\n\",training_errors)\n",
    "print (\"test errors: \\n\",test_errors)\n",
    "#print (\"distribution errors: \\n\", distribution_errors)\n",
    "\n",
    "# 绘制图片\n",
    "plt.rcParams['figure.figsize'] = (8.0, 6.0)\n",
    "plt.plot(training_errors, '-.', mfc=\"none\", mec='#e4007f', ms=10, c='#e4007f', label=\"Training\")\n",
    "plt.plot(test_errors, '--', mfc=\"none\", mec='#f19ec2', ms=10, c='#f19ec2', label=\"Test\")\n",
    "#plt.plot(distribution_errors, '-', mfc=\"none\", mec=\"#3D3D3F\", ms=10, c=\"#3D3D3F\", label=\"Distribution\")\n",
    "plt.legend(fontsize='x-large')\n",
    "plt.xlabel(\"degree\")\n",
    "plt.ylabel(\"MSE\")\n",
    "plt.savefig('ml-mse-error.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "观察可视化结果：\n",
    "* 当阶数较低的时候，模型的表示能力有限，训练误差和测试误差都很高，代表模型欠拟合；\n",
    "* 当阶数较高的时候，模型表示能力强，但将训练数据中的噪声也作为特征进行学习，一般情况下训练误差继续降低而测试误差显著升高，代表模型过拟合。\n",
    "> 此处多项式阶数大于等于5时，训练误差并没有下降，尤其是在多项式阶数为7时，训练误差变得非常大，请思考原因？提示：请从幂函数特性角度思考。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "对于模型过拟合的情况，可以引入正则化方法，通过向误差函数中添加一个**惩罚项**来避免系数倾向于较大的取值。下面加入$\\mathcal{l_{2}}$正则化项，查看拟合结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:31: DeprecationWarning: invalid escape sequence \\e\n",
      "<>:31: DeprecationWarning: invalid escape sequence \\e\n",
      "<>:31: DeprecationWarning: invalid escape sequence \\e\n",
      "/tmp/ipykernel_208/1206503974.py:31: DeprecationWarning: invalid escape sequence \\e\n",
      "  plt.plot(X_underlying, y_underlying_pred_reg, c='#f19ec2', linestyle=\"-.\", label=\"$deg. = 8, \\ell_2 reg$\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mse: 3919046.75\n",
      "mse_with_l2_reg: 0.42932215332984924\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "degree = 8 # 多项式阶数\n",
    "reg_lambda = 0.0001 # 正则化系数\n",
    "\n",
    "X_train_transformed = polynomial_basis_function(X_train.reshape([-1,1]), degree)\n",
    "X_test_transformed = polynomial_basis_function(X_test.reshape([-1,1]), degree)\n",
    "X_underlying_transformed = polynomial_basis_function(X_underlying.reshape([-1,1]), degree)\n",
    "\n",
    "model = Linear(degree) \n",
    "\n",
    "optimizer_lsm(model,X_train_transformed,y_train.reshape([-1,1]))\n",
    "\n",
    "y_test_pred=model(X_test_transformed).squeeze()\n",
    "y_underlying_pred=model(X_underlying_transformed).squeeze()\n",
    "\n",
    "model_reg = Linear(degree) \n",
    "\n",
    "optimizer_lsm(model_reg,X_train_transformed,y_train.reshape([-1,1]),reg_lambda=reg_lambda)\n",
    "\n",
    "y_test_pred_reg=model_reg(X_test_transformed).squeeze()\n",
    "y_underlying_pred_reg=model_reg(X_underlying_transformed).squeeze()\n",
    "\n",
    "mse = mean_squared_error(y_true = y_test, y_pred = y_test_pred).item()\n",
    "print(\"mse:\",mse)\n",
    "mes_reg = mean_squared_error(y_true = y_test, y_pred = y_test_pred_reg).item()\n",
    "print(\"mse_with_l2_reg:\",mes_reg)\n",
    "\n",
    "# 绘制图像\n",
    "plt.scatter(X_train, y_train, facecolor=\"none\", edgecolor=\"#e4007f\", s=50, label=\"train data\")\n",
    "plt.plot(X_underlying, y_underlying, c='#000000', label=r\"$\\sin(2\\pi x)$\")\n",
    "plt.plot(X_underlying, y_underlying_pred, c='#e4007f', linestyle=\"--\", label=\"$deg. = 8$\")\n",
    "plt.plot(X_underlying, y_underlying_pred_reg, c='#f19ec2', linestyle=\"-.\", label=\"$deg. = 8, \\ell_2 reg$\")\n",
    "plt.ylim(-1.5, 1.5)\n",
    "plt.annotate(\"lambda={}\".format(reg_lambda), xy=(0.82, -1.4))\n",
    "plt.legend(fontsize='large')\n",
    "plt.savefig('ml-vis4.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "观察可视化结果，其中黄色曲线为加入$\\mathcal{l_{2}}$正则后多项式分布拟合结果，红色曲线为未加入$\\mathcal{l_{2}}$正则的拟合结果，黄色曲线的拟合效果明显好于红色曲线。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 思考\n",
    "\n",
    "如果训练数据中存在一些异常样本，会对最终模型有何影响？怎样处理可以尽可能减少异常样本对模型的影响？"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
